/*
 * Copyright 2002-2021 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.context.support;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.core.OrderComparator;
import org.springframework.core.Ordered;
import org.springframework.core.PriorityOrdered;
import org.springframework.core.metrics.ApplicationStartup;
import org.springframework.core.metrics.StartupStep;
import org.springframework.lang.Nullable;

/**
 * Delegate for AbstractApplicationContext's post-processor handling.
 *
 * @author Juergen Hoeller
 * @author Sam Brannen
 * @since 4.0
 */
// ====== 后置处理器注册委托类
final class PostProcessorRegistrationDelegate {

	private PostProcessorRegistrationDelegate() {
	}

	// ====== 目标：
	/* ======
 	 	这里我们做两个简称：BF后置=BeanFactoryPostProcessor接口，BD后置=BeanDefinitionRegistryPostProcessor接口
	 	其中 BD后置 extends BF后置，这个可以通过查看BD接口的源码得到验证！所以调用顺序如下
	 	1、查找顺序：参数传进来的 - Factory中的BD后置 - Factory中的BF后置
	 	2、在调BD后置的时候，由于BD继承了BF，所以先调BD中子接口方法，后调继承的BF方法
	 	3、无论factory中的BD还是BF，都有可能实现PriorityOrdered或者Ordered接口
	 	那么优先级将是这样的：PriorityOrdered - Ordered - 没实现的
 	*/
	/** ######
	 * BeanFactoryPostProcessors按入场方式分为：
	 * 1. 程序员调用ApplicationContext的API手动添加
	 * 2. Spring自己扫描出来的
	 *
	 * BeanFactoryPostProcessor按类型又可以分为：
	 * 1. 普通BeanFactoryPostProcessor
	 * 2. BeanDefinitionRegistryPostProcessor
	 *
	 * 执行顺序顺序如下：
	 * 1. 执行手动添加的BeanDefinitionRegistryPostProcessor                       的postProcessBeanDefinitionRegistry()方法
	 * 2. 执行扫描出来的BeanDefinitionRegistryPostProcessor（实现了PriorityOrdered）的postProcessBeanDefinitionRegistry()方法
	 * 3. 执行扫描出来的BeanDefinitionRegistryPostProcessor（实现了Ordered）		   的postProcessBeanDefinitionRegistry()方法
	 * 4. 执行扫描出来的BeanDefinitionRegistryPostProcessor（普通）				   的postProcessBeanDefinitionRegistry()方法
	 * 5. 执行扫描出来的BeanDefinitionRegistryPostProcessor（所有）				   的postProcessBeanFactory()方法
	 * 6. 执行手动添加的BeanFactoryPostProcessor								   的postProcessBeanFactory()方法
	 * 7. 执行扫描出来的BeanFactoryPostProcessor（实现了PriorityOrdered）		   的postProcessBeanFactory()方法
	 * 8. 执行扫描出来的BeanFactoryPostProcessor（实现了Ordered）		   		   的postProcessBeanFactory()方法
	 * 9. 执行扫描出来的BeanFactoryPostProcessor（普通）				   		   的postProcessBeanFactory()方法
	 *
	 * ConfigurationClassPostProcessor就会在第2步执行，会进行扫描
	 */
	public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

		// WARNING: Although it may appear that the body of this method can be easily
		// refactored to avoid the use of multiple loops and multiple lists, the use
		// of multiple lists and multiple passes over the names of processors is
		// intentional. We must ensure that we honor the contracts for PriorityOrdered
		// and Ordered processors. Specifically, we must NOT cause processors to be
		// instantiated (via getBean() invocations) or registered in the ApplicationContext
		// in the wrong order.
		//
		// Before submitting a pull request (PR) to change this method, please review the
		// list of all declined PRs involving changes to PostProcessorRegistrationDelegate
		// to ensure that your proposal does not result in a breaking change:
		// https://github.com/spring-projects/spring-framework/issues?q=PostProcessorRegistrationDelegate+is%3Aclosed+label%3A%22status%3A+declined%22

        // 无论是什么情况，优先执行BeanDefinitionRegistryPostProcessors
        // 将已经执行过的BFPP存储在processedBeans中，防止重复执行
		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
		Set<String> processedBeans = new HashSet<>();
		// 判断beanfactory是否是BeanDefinitionRegistry类型，此处是DefaultListableBeanFactory,实现了BeanDefinitionRegistry接口，所以为true
		// ====== 为true:
		// ====== beanFactory为DefaultListableBeanFactory,
		// ====== 而DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，因此这边为true
		// ====== 通过查看接口的实现类，可以验证！
		//对BeanDefinitionRegistry类型的处理
		if (beanFactory instanceof BeanDefinitionRegistry) {
			// 类型转换
			// ====== 进入
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            // 此处希望大家做一个区分，两个接口是不同的，BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子集
            // BeanFactoryPostProcessor主要针对的操作对象是BeanFactory，而BeanDefinitionRegistryPostProcessor主要针对的操作对象是BeanDefinition
            // 存放BeanFactoryPostProcessor的集合
			// ====== 定义俩临时变量集合，一个存放BF后置处理器，一个存放BD后置处理器
			// ====== 临时变量，用于存放BeanFactoryPostProcessor（工厂）
			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			// 存放BeanDefinitionRegistryPostProcessor的集合
			// ====== 临时变量，用于存放BeanDefinitionRegistryPostProcessor
			// ======（实际上BD接口继承了上面的BF接口，可以通过源码验证）
			// BeanDefinitionRegistryPostProcessor
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

			// ###### 该部分会将方法参数中传入的BeanFactoryPostProcessor分离开
            // 首先处理入参中的beanFactoryPostProcessors,遍历所有的beanFactoryPostProcessors，将BeanDefinitionRegistryPostProcessor
            // 和BeanFactoryPostProcessor区分开
			// ======  2.首先处理入参中传进来的beanFactoryPostProcessors
			// ======  这些Processer是直接add到Context的属性上的，这里为空，不管他
			// ======  参考 AbstractApplicationContext.beanFactoryPostProcessors 属性
			// ###### beanFactoryPostProcessors集合一般情况下都是空的，除非我们手动调用容器的addBeanFactoryPostProcessor方法添加了
			// ###### beanFactoryPostProcessors中可能包含了：普通BeanFactoryPostProcessor对象和BeanDefinitionRegistryPostProcessor对象
			// ###### 对于BeanDefinitionRegistryPostProcessor对象，会执行自己的postProcessBeanDefinitionRegistry()方法
			/*
			 * 硬编码注册的后处理器
			 */
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				// 如果是BeanDefinitionRegistryPostProcessor
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					// ====== 2.1 如果是BeanDefinitionRegistryPostProcessor的实现类，调子接口方法
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					//直接执行BeanDefinitionRegistryPostProcessor接口中的postProcessBeanDefinitionRegistry方法
					// ====== 2.1.1 先执行它实现的 postProcessBeanDefinitionRegistry方法（BD接口里定义，BF里没有）
					//对于BeanDefinitionRegistryPostProcessor类型，在BeanFactoryPostProcessor的基础上还有自己定义的方法，需要先调用
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					//添加到registryProcessors，用于后续执行postProcessBeanFactory方法
					// ====== 2.1.2 然后添加到registryProcessors临时变量(用于最后执行BF的postProcessBeanFactory方法)
					registryProcessors.add(registryProcessor);
				}
				else {
					//否则，只是普通的BeanFactoryPostProcessor，添加到regularPostProcessors，用于后续执行postProcessBeanFactory方法
					// ====== 2.2 否则，只是普通的BeanFactoryPostProcessor
					// ====== 2.2.1 那就直接添加到regularPostProcessors临时变量去(用于最后执行postProcessBeanFactory方法)
					//记录常规BeanFactoryPostProcessor
					regularPostProcessors.add(postProcessor);
				}
			}

			//用于保存本次要执行的BeanDefinitionRegistryPostProcessor
			// ====== 3.调用所有实现PriorityOrdered接口的BD后置实现类
			// ====== 临时变量用于保存找到的的BeanDefinitionRegistryPostProcessor
			// Do not initialize FactoryBeans here: We need to leave all regular beans
			// uninitialized to let the bean factory post-processors apply to them!
			// Separate between BeanDefinitionRegistryPostProcessors that implement
			// PriorityOrdered, Ordered, and the rest.
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			// ###### 首先,执行实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessors
            //调用所有实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor实现类
            //找到所有实现BeanDefinitionRegistryPostProcessor接口bean的beanName
			// ====== 3.1 先找出所有实现了BD后置接口的Bean的beanName
			// ###### 执行扫描出来的BeanDefinitionRegistryPostProcessor
			//配置注册的后处理器
			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			//遍历处理所有符合规则的postProcessorNames
			// ====== 3.2 遍历这些bean
			for (String ppName : postProcessorNames) {
				//检测是否实现了PriorityOrdered接口
				// ======  3.3 过滤实现了PriorityOrdered接口的，其他的不要
				// ======  PriorityOrdered接口是空的，继承了Ordered接口，Ordered里有个getOrder方法标识了顺序
				// ======  这个接口的意义在于，可以允许你定义带优先级的BD后置处理器，spring会按你的顺序执行
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { // ===>  PriorityOrdered接口方法
					//获取名字对应的bean实例，添加到currentRegistryProcessors中
					// ====== 3.3 放到临时变量里去，只放实现了PriorityOrdered接口的
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					//将要被执行的BFPP名称添加到processedBeans，避免后续重复执行
					// ====== 3.4 将要被执行的bean name加入processedBeans，避免后续重复执行
					processedBeans.add(ppName);
				}
			}
			//按照优先级进行排序操作
			// ====== 3.6 进行排序(根据getOrder方法的返回值，从小到大排序。注意看控制台，看执行后current里的顺序)
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			//添加到registryProcessors中，用于最后执行postProcessBeanFactory方法
			// ====== 3.7 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
			registryProcessors.addAll(currentRegistryProcessors);
			//遍历currentRegistryProcessors，执行postProcessBeanDefinitionRegistry方法
			// ====== 3.8 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
			// ====== 注意这货已经排过序，所以会按照排好的次序执行，这就实现了自定义后置的有序执行！！！
			//激活postProcessBeanFactory方法之前,先激活【实现了PriorityOrdered接口】的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
			//执行完毕之后，清空currentRegistryProcessors
			// ====== 3.9 执行完毕后, 清空currentRegistryProcessors
			currentRegistryProcessors.clear();

			// ###### 接下来执行实现Ordered接口的BeanDefinitionRegistryPostProcessors
            //调用所有实现Ordered接口的BeanDefinitionRegistryPostProcessor实现类
            //找到所有实现BeanDefinitionRegistryPostProcessor接口bean的beanName，
            //此处需要重复查找的原因在于上面的执行过程中可能会新增其他的BeanDefinitionRegistryPostProcessor
			// ====== 4.上面是实现了PriorityOrdered的，这步是Ordered接口的（过程跟上面的步骤3基本一样）
			// ====== 4.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的类, 这边重复查找是因为执行完上面的
			// ====== 可能会有变动, 因此重新查一遍
			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				//检测是否实现了Ordered接口，并且还未执行过
				// ###### processedBeans表示该beanFactoryPostProcessor的postProcessBeanDefinitionRegistry()方法已经执行过了，不再重复执行
				// ======  校验是否还未执行过！关键点：上一步已经执行过的name放入了processedBeans
				// ======  所以这一步不会发生重复执行行为，要知道，PriorityOrdered继承了Ordered，必须排重
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					//获取名字对应的bean实例，添加到currentRegistryProcessors中
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					//将要被执行的BFPP名称添加到processedBeans，避免后续重复执行
					processedBeans.add(ppName);
				}
			}
			//按照优先级进行排序操作
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			//添加到registryProcessors中，用于最后执行postProcessBeanFactory方法
			registryProcessors.addAll(currentRegistryProcessors);
			//遍历currentRegistryProcessors，执行postProcessBeanDefinitionRegistry方法
			// ====== 一个德行，先执行完postProcessBeanDefinitionRegistry方法
			//激活postProcessBeanFactory方法之前,先激活【实现了Ordered接口】的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
			//执行完毕之后，清空currentRegistryProcessors
			currentRegistryProcessors.clear();

			// ###### 最后执行所有其他BeanDefinitionRegistryPostProcessor
			//最后，调用所有剩下的BeanDefinitionRegistryPostProcessors
			// ======  5.最后, 调用所有剩下的BD，这些都没实现排序接口
			/** ######
				Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
				执行哪些没有实现了PriorityOrdered或Ordered接口的普通BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法
				在这个过程中可能会向BeanFactory中注册另外的BeanDefinitionRegistryPostProcessor，所以需要while，直到确定所有的BeanDefinitionRegistryPostProcessor都执行完了
				在这个过程中注册的BeanDefinitionRegistryPostProcessor，所实现的PriorityOrdered或Ordered接口可能会不按顺序执行
				比如 A注册了B和C,B又注册了D和E,那么B和C会按顺序执行，D和E也会按顺序执行，但是B、C、D、E整体不能保证是顺序执行
			 */
			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			boolean reiterate = true;
			while (reiterate) { //注意此处有一个循环动作
				reiterate = false;
				//找出所有实现BeanDefinitionRegistryPostProcessor接口的类
				// ====== 5.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的类
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				//遍历执行
				for (String ppName : postProcessorNames) {
					//跳过已经执行过的BeanDefinitionRegistryPostProcessor
					// ====== 5.2 跳过已经执行过的
					if (!processedBeans.contains(ppName)) {
						//获取名字对应的bean实例，添加到currentRegistryProcessors中
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						//将要被执行的BFPP名称添加到processedBeans，避免后续重复执行
						processedBeans.add(ppName);
						// ====== 5.3 如果有BeanDefinitionRegistryPostProcessor被执行, 则有可能会产生新的BeanDefinitionRegistryPostProcessor,
						// ====== 因此这边将reiterate赋值为true, 代表需要再循环查找一次
						reiterate = true;
					}
				}
				//按照优先级进行排序操作
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				//添加到registryProcessors中，用于最后执行postProcessBeanFactory方法
				registryProcessors.addAll(currentRegistryProcessors);
				//遍历currentRegistryProcessors，执行postProcessBeanDefinitionRegistry方法
				// ====== 还是一个德行，先把子接口BD里的执行完
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
				//执行完毕之后，清空currentRegistryProcessors
				currentRegistryProcessors.clear();
			}

			// ###### 先回调BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
			// 调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
			// ====== 6.调用所有BD后置处理器里的postProcessBeanFactory方法，其实这个方法是它从BF后置接口继承过来的
			// ###### 执行完BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法后，
			// ###### 再执行BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法
			//激活postProcessBeanFactory方法
			//包含硬编码设置的BeanDefinitionRegistryPostProcessor和配置的BeanDefinitionRegistryPostProcessor
			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			// ###### 再调用编程式注入的BeanFactoryPostProcessor
			// 最后，调用入参beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的postProcessBeanFactory方法
			// ====== 7.最后, 调用BF后置处理器的postProcessBeanFactory方法
			// ###### 执行手动添加的普通BeanFactoryPostProcessor的postProcessBeanFactory()方法
			//常规BeanFactoryPostProcessor
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}
		// ###### 如果BeanFactory没有实现BeanDefinitionRegistry接口,则进入下面的流程
		else {
			// ###### 仅调用编程式注册的BeanFactoryPostProcessor
			//如果beanFactory不归属于BeanDefinitionRegistry类型，那么直接执行postProcessBeanFactory方法
			// ====== 在上下文中注册的BF后置处理器
			// Invoke factory processors registered with the context instance.
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

        // 到这里为止，入参beanFactoryPostProcessors和容器中的所有BeanDefinitionRegistryPostProcessor已经全部处理完毕，下面开始处理容器中
        // 所有的BeanFactoryPostProcessor
        // 可能会包含一些实现类，只实现了BeanFactoryPostProcessor，并没有实现BeanDefinitionRegistryPostProcessor接口

		// ###### 下面的部分是回调BeanFactoryPostProcessor,思路与上面的几乎一样
		// 找到所有实现BeanFactoryPostProcessor接口的类
		// ====== 到这里 , 参数传进来的和容器中的所有BD后置处理器已经全部处理完毕,
		// ====== 下面开始处理容器中的所有BF后置处理器
		// ###### 执行扫描出来的普通BeanFactoryPostProcessor
		// 对于配置中读取的BeanFactoryPostProcessor的处理
		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let the bean factory post-processors apply to them!
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		
		// ====== 还是处理三类，从前到后。PriorityOrdered - Ordered - 普通的
		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		//用于存放实现了PriorityOrdered接口的BeanFactoryPostProcessor
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		//用于存放实现了Ordered接口的BeanFactoryPostProcessor的beanName
		List<String> orderedPostProcessorNames = new ArrayList<>();
		//用于存放普通BeanFactoryPostProcessor的beanName
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		//遍历postProcessorNames,将BeanFactoryPostProcessor按实现PriorityOrdered、实现Ordered接口、普通三种区分开
		// ###### 先进行分类
		//对后处理器进行分类
		for (String ppName : postProcessorNames) {
			//跳过已经执行过的BeanFactoryPostProcessor
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
				//已经处理过,跳过
			}
			//添加实现了PriorityOrdered接口的BeanFactoryPostProcessor到priorityOrderedPostProcessors
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			//添加实现了Ordered接口的BeanFactoryPostProcessor的beanName到orderedPostProcessorNames
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			//添加剩下的普通BeanFactoryPostProcessor的beanName到nonOrderedPostProcessorNames
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// ###### 首先,执行实现PriorityOrdered接口的BeanFactoryPostProcessor
		// 对实现了PriorityOrdered接口的BeanFactoryPostProcessor进行排序
		// 按照优先级进行排序
		// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		//遍历实现了PriorityOrdered接口的BeanFactoryPostProcessor，执行postProcessBeanFactory方法
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// ###### 然后,执行实现Ordered接口的BeanFactoryPostProcessor
		//创建存放实现了Ordered接口的BeanFactoryPostProcessor集合
		// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		//遍历存放实现了Ordered接口的BeanFactoryPostProcessor名字的集合
		for (String postProcessorName : orderedPostProcessorNames) {
			//将实现了Ordered接口的BeanFactoryPostProcessor添加到集合中
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		//对实现了Ordered接口的BeanFactoryPostProcessor进行排序操作
		// 按照order排序
		sortPostProcessors(orderedPostProcessors, beanFactory);
		//遍历实现了Ordered接口的BeanFactoryPostProcessor，执行postProcessBeanFactory方法
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// ###### 最后,执行普通的BeanFactoryPostProcessor
		// 最后，创建存放普通的BeanFactoryPostProcessor的集合
		// 无序,直接调用
		// Finally, invoke all other BeanFactoryPostProcessors.
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		//遍历存放实现了普通BeanFactoryPostProcessor名字的集合
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			//将普通的BeanFactoryPostProcessor添加到集合中
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		//遍历普通的BeanFactoryPostProcessor，执行postProcessBeanFactory方法
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// ###### 清理缓存
        //清除元数据缓存（mergeBeanDefinitions、allBeanNamesByType、singletonBeanNameByType）
        //因为后置处理器可能已经修改了原始元数据，例如，替换值中的占位符
		// Clear cached merged bean definitions since the post-processors might have
		// modified the original metadata, e.g. replacing placeholders in values...
		beanFactory.clearMetadataCache();
	}

    /**
     * 注册beanPostProcessor
     * @param beanFactory
     * @param applicationContext
     */
	// ====== 目标：
	// ====== 核心：和前面的一样，3步；最终目的都是实现bean后置处理器的注册
	/** ======
		  第一步： implement PriorityOrdered
		  第二步： implement Ordered.
		  第三步： Register all internal BeanPostProcessors
		  注意！本方法并没有去执行你定义的process方法，只是梳理并注册到factory的一个CopyOnWriteArrayList里(AbstractBeanFactory的beanPostProcessors属性)
		  可以仔细查看控制台，直到方法结束，都没有被执行和打印
		  真正执行的时候，到很久以后了。finishBeanFactoryInitialization 这一步初始化bean前后.
	 */
	public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

		// WARNING: Although it may appear that the body of this method can be easily
		// refactored to avoid the use of multiple loops and multiple lists, the use
		// of multiple lists and multiple passes over the names of processors is
		// intentional. We must ensure that we honor the contracts for PriorityOrdered
		// and Ordered processors. Specifically, we must NOT cause processors to be
		// instantiated (via getBean() invocations) or registered in the ApplicationContext
		// in the wrong order.
		//
		// Before submitting a pull request (PR) to change this method, please review the
		// list of all declined PRs involving changes to PostProcessorRegistrationDelegate
		// to ensure that your proposal does not result in a breaking change:
		// https://github.com/spring-projects/spring-framework/issues?q=PostProcessorRegistrationDelegate+is%3Aclosed+label%3A%22status%3A+declined%22
		
		// 找到所有实现了BeanPostProcessor接口的类
		// ====== 1.找出所有直接实现BeanPostProcessor接口的类
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		// ###### 此处会先注册一个BeanPostProcessorChecker
        // 记录下BeanPostProcessor的目标计数
        // 此处为什么要+1呢，原因非常简单，在此方法的最后会添加一个BeanPostProcessorChecker的类
		// ====== 加一个Processor数量检查器，就是数量不对的话打个info信息
		// ====== beanFactory.getBeanPostProcessorCount()：系统注册到工厂里的
		// ****** 在prepareBeanFactory(beanFactory)中执行了beanFactory.addBeanPostProcessor,向AbstractBeanFactory的beanPostProcessors属性添加内置的后置处理器
		// ====== postProcessorNames.length ：我们自己实现BeanPostProcessor接口的类
		// ====== 那么上面两项加起来不就是总数吗？  +1 又是个什么鬼？？？
		// ====== 因为，下面new并add的这个checker本身也是个Processor！要把它也算上，数量才对
		// ###### beanProcessorTargetCount表示BeanFactory中所有的BeanPostProcessor数量，+1表示BeanPostProcessorChecker
		// Register BeanPostProcessorChecker that logs an info message when
		// a bean is created during BeanPostProcessor instantiation, i.e. when
		// a bean is not eligible for getting processed by all BeanPostProcessors.
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		// 添加BeanPostProcessorChecker(主要用于记录信息)到beanFactory中
		// ====== 2.添加BeanPostProcessorChecker(主要用于记录信息)到beanFactory中
		/*
		 * BeanPostProcessorChecker是一个普通的信息打印，可能会有些情况，
		 * 当Spring的配置中的后处理器还没有被注册就已经开始了bean的初始化时
		 * 便会打印出BeanPostProcessorChecker中设定的信息
		 */
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// ###### 根据排序规则,给所有的后置处理器分类
		// ====== 3.定义不同的变量用于区分，其实目的还是为了让你能控制处理器的执行顺序和优先级
		// ======   实现PriorityOrdered接口的BeanPostProcessor
		// ======   实现Ordered接口的BeanPostProcessor
		// ======   普通BeanPostProcessor
		// 定义存放实现了PriorityOrdered接口的BeanPostProcessor集合
		// Separate between BeanPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		// ====== 3.1 继承自PriorityOrdered接口的
		// 使用PriorityOrdered保证顺序
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		// 定义存放spring内部的BeanPostProcessor
		// ====== 3.2 internalPostProcessors: 用于存放Spring内部的BeanPostProcessor
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		// 定义存放实现了Ordered接口的BeanPostProcessor的name集合
		// ====== 3.3 orderedPostProcessorNames: 用于存放实现Ordered接口的
		// 使用Ordered保证顺序
		List<String> orderedPostProcessorNames = new ArrayList<>();
		// 定义存放普通的BeanPostProcessor的name集合
		// ====== 3.4 nonOrderedPostProcessorNames: 用于存放普通的beanName
		// 无序BeanPostProcessor
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();

		// 遍历beanFactory中存在的BeanPostProcessor的集合postProcessorNames
		// ====== 4.遍历postProcessorNames, 将BeanPostProcessors按3.1 - 3.4定义的变量区分开
		for (String ppName : postProcessorNames) {
			// 如果ppName对应的BeanPostProcessor实例实现了PriorityOrdered接口，则获取到ppName对应的BeanPostProcessor的实例添加到priorityOrderedPostProcessors中
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				// ###### 注意此处,PriorityOrdered类型的后置处理器被提前初始化了
				// ====== PriorityOrdered的
				// ====== 4.1 如果ppName对应的Bean实例实现了PriorityOrdered接口,
				// ====== 则拿到ppName对应的Bean实例并添加到priorityOrderedPostProcessors
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				// ###### MergedBeanDefinitionPostProcessor类型的后置处理器被单独放在一个集合中,
				// ###### 说明该接口比较特殊
				// 如果ppName对应的BeanPostProcessor实例也实现了MergedBeanDefinitionPostProcessor接口，那么则将ppName对应的bean实例添加到internalPostProcessors中
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					// ====== 实现了merged接口的，放在internal
					// ====== 4.2 如果ppName对应的Bean实例也实现了MergedBeanDefinitionPostProcessor接口,
					// ====== 则将ppName对应的Bean实例添加到internalPostProcessors
					internalPostProcessors.add(pp);
				}
			}
			// 如果ppName对应的BeanPostProcessor实例没有实现PriorityOrdered接口，但是实现了Ordered接口，那么将ppName对应的bean实例添加到orderedPostProcessorNames中
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				// ====== Ordered的
				orderedPostProcessorNames.add(ppName);
			}
			else {
				// 否则将ppName添加到nonOrderedPostProcessorNames中
				// ====== 没实现排序接口的
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// ###### 注册实现了PriorityOrdered接口的BeanPostProcessor
		// 首先，对实现了PriorityOrdered接口的BeanPostProcessor实例进行排序操作
		// ======  5.  统计分类并加载到AbstractBeanFactory的beanPostProcessors列表里去
		// ======  这是一个CopyOnWriteArrayList变量，所以，会保持你放进去时候的顺序
		// ======  注意！这时候并没有触发processor里的方法调用。只是把它整理到了list里去（注册）
		// ======  5.1 排序，整理PriorityOrdered的
		// 第一步，注册所有实现PriorityOrdered的BeanPostProcessor
		// First, register the BeanPostProcessors that implement PriorityOrdered.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		// 注册实现了PriorityOrdered接口的BeanPostProcessor实例添加到beanFactory中
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);// ===> 啥也没干，只是add到BF里去

		// ###### 注册实现了Ordered接口的BeanPostProcessor
		// 注册所有实现Ordered的beanPostProcessor
		// ======  5.2 ordered的.
		// 第二步，注册所有实现Ordered的BeanPostProcessor
		// Next, register the BeanPostProcessors that implement Ordered.
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String ppName : orderedPostProcessorNames) {
			//根据ppName找到对应的BeanPostProcessor实例对象
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			//将实现了Ordered接口的BeanPostProcessor添加到orderedPostProcessors集合中
			orderedPostProcessors.add(pp);
			//如果ppName对应的BeanPostProcessor实例也实现了MergedBeanDefinitionPostProcessor接口，那么则将ppName对应的bean实例添加到internalPostProcessors中
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		//对实现了Ordered接口的BeanPostProcessor进行排序操作
		sortPostProcessors(orderedPostProcessors, beanFactory);
	    //注册实现了Ordered接口的BeanPostProcessor实例添加到beanFactory中
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// ###### 注册普通的BeanPostProcessor
		//创建存放没有实现PriorityOrdered和Ordered接口的BeanPostProcessor的集合
		// ====== 5.3 没有实现排序接口的.
		// 第三步，注册所有无序的BeanPostProcessor
		// Now, register all regular BeanPostProcessors.
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		//遍历集合
		for (String ppName : nonOrderedPostProcessorNames) {
			//根据ppName找到对应的BeanPostProcessor实例对象
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			//将没有实现PriorityOrdered和Ordered接口的BeanPostProcessor添加到nonOrderedPostProcessors集合中
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		//注册没有实现PriorityOrdered和Ordered的BeanPostProcessor实例添加到beanFactory中
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// ###### 最后,重新注册被单独分离出来的MergedBeanDefinitionPostProcessor
		//将所有实现了MergedBeanDefinitionPostProcessor类型的BeanPostProcessor进行排序操作
		// ====== 5.4  最后，internal接口的（优先级最低）
		// ###### MergedBeanDefinitionPostProcessor排在最后
		// 第四步，注册所有MergedBeanDefinitionPostProcessor类型的BeanPostProcessor，并非重复注册
		// Finally, re-register all internal BeanPostProcessors.
		sortPostProcessors(internalPostProcessors, beanFactory);
		//注册所有实现了MergedBeanDefinitionPostProcessor类型的BeanPostProcessor到beanFactory中
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		// ###### 手动注册ApplicationListenerDetector
		// 注册ApplicationListenerDetector到beanFactory中
		// ###### ApplicationListenerDetector放在所有BeanPostProcessor之后，注意ApplicationListenerDetector的equals()方法实现
		// 重新注册一次ApplicationListenerDetector,这个BeanPostProcessor在prepareBeanFactory(beanFactory)方法中有注册过
		// 添加ApplicationListener探测器
		// Re-register post-processor for detecting inner beans as ApplicationListeners,
		// moving it to the end of the processor chain (for picking up proxies etc).
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}

	/**
	 * 对 postProcessors 进行排序，优先使用beanFactory的DependencyComparator，获取不到就使用OrderComparator.INSTANCE
	 * @param postProcessors
	 * @param beanFactory
	 */
	private static void sortPostProcessors(List<?> postProcessors, ConfigurableListableBeanFactory beanFactory) {
		// Nothing to sort?
		// 如果postProcessors的个数小于等于1，那么不做任何排序操作
		if (postProcessors.size() <= 1) {
			return;
		}
		Comparator<Object> comparatorToUse = null;
		// 判断是否是DefaultListableBeanFactory类型
		if (beanFactory instanceof DefaultListableBeanFactory) {
			// 获取设置的比较器
			comparatorToUse = ((DefaultListableBeanFactory) beanFactory).getDependencyComparator();
		}
		if (comparatorToUse == null) {
			// OrderComparator.INSTANCE:有序对象的比较实现，按顺序值升序或优先级降序排序,优先级由上往下：
			// 1.PriorityOrderd对象
			// 2.一些Order对象
			// 3.无顺序对象
			comparatorToUse = OrderComparator.INSTANCE;
		}
		// 使用比较器对postProcessors进行排序
		postProcessors.sort(comparatorToUse);
	}

	/**
	 * Invoke the given BeanDefinitionRegistryPostProcessor beans.
	 */
	//调用给定 BeanDefinitionRegistryPostProcessor Bean对象
	private static void invokeBeanDefinitionRegistryPostProcessors(
			Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry, ApplicationStartup applicationStartup) {

		for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
			StartupStep postProcessBeanDefRegistry = applicationStartup.start("spring.context.beandef-registry.post-process")
					.tag("postProcessor", postProcessor::toString);
			postProcessor.postProcessBeanDefinitionRegistry(registry);
			postProcessBeanDefRegistry.end();
		}
	}

	/**
	 * Invoke the given BeanFactoryPostProcessor beans.
	 */
	//调用给定的 BeanFactoryPostProcessor类型Bean对象
	private static void invokeBeanFactoryPostProcessors(
			Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {

		for (BeanFactoryPostProcessor postProcessor : postProcessors) {
			StartupStep postProcessBeanFactory = beanFactory.getApplicationStartup().start("spring.context.bean-factory.post-process")
					.tag("postProcessor", postProcessor::toString);
			postProcessor.postProcessBeanFactory(beanFactory);
			postProcessBeanFactory.end();
		}
	}

	/**
	 * Register the given BeanPostProcessor beans.
	 */
	//注册给定的BeanPostProcessor类型Bean对象
	private static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {

		if (beanFactory instanceof AbstractBeanFactory) {
			// Bulk addition is more efficient against our CopyOnWriteArrayList there
			((AbstractBeanFactory) beanFactory).addBeanPostProcessors(postProcessors);
		}
		else {
			for (BeanPostProcessor postProcessor : postProcessors) {
				beanFactory.addBeanPostProcessor(postProcessor);
			}
		}
	}


	/**
	 * BeanPostProcessor that logs an info message when a bean is created during
	 * BeanPostProcessor instantiation, i.e. when a bean is not eligible for
	 * getting processed by all BeanPostProcessors.
	 */
	//当前Bean在BeanPostProcessor实例化过程中被创建时，即当前一个Bean不适合被所有BeanPostProcessor处理时，记录一个信息消息
	private static final class BeanPostProcessorChecker implements BeanPostProcessor {

		private static final Log logger = LogFactory.getLog(BeanPostProcessorChecker.class);

		//当前Bean工厂
		private final ConfigurableListableBeanFactory beanFactory;

		//BeanPostProcessor目标数量
		private final int beanPostProcessorTargetCount;

		//创建一个 BeanPostProcessorCheker 实例
		public BeanPostProcessorChecker(ConfigurableListableBeanFactory beanFactory, int beanPostProcessorTargetCount) {
			this.beanFactory = beanFactory;
			this.beanPostProcessorTargetCount = beanPostProcessorTargetCount;
		}

		/**
		 * 后置处理器的before方法，什么都不做，直接返回对象
		 * @param bean the new bean instance
		 * @param beanName the name of the bean
		 * @return
		 */
		@Override
		public Object postProcessBeforeInitialization(Object bean, String beanName) {
			return bean;
		}

		/**
		 * 后置处理器的after方法，用来判断哪些是不需要检测的bean
		 * @param bean the new bean instance
		 * @param beanName the name of the bean
		 * @return
		 */
		@Override
		public Object postProcessAfterInitialization(Object bean, String beanName) {
			//此处判断是否有普通bean对象被提前创建
			if (!(bean instanceof BeanPostProcessor) && !isInfrastructureBean(beanName) &&
					this.beanFactory.getBeanPostProcessorCount() < this.beanPostProcessorTargetCount) {
				//打印异常警告日志
				if (logger.isInfoEnabled()) {
					logger.info("Bean '" + beanName + "' of type [" + bean.getClass().getName() +
							"] is not eligible for getting processed by all BeanPostProcessors " +
							"(for example: not eligible for auto-proxying)");
				}
			}
			return bean;
		}

		/**
		 * 判断 beanName 是否是 完全内部使用
		 * @param beanName
		 * @return
		 */
		private boolean isInfrastructureBean(@Nullable String beanName) {
			if (beanName != null && this.beanFactory.containsBeanDefinition(beanName)) {
				BeanDefinition bd = this.beanFactory.getBeanDefinition(beanName);
				return (bd.getRole() == RootBeanDefinition.ROLE_INFRASTRUCTURE);
			}
			return false;
		}
	}

}
